/**
 * 缓存管理工具
 * 提供统一的缓存清理功能和标签页隔离的token管理
 */

// 需要清理的缓存键名列表
const CACHE_KEYS = {
  // 认证相关
  AUTH_TOKEN: 'admin_token',
  
  // 用户偏好设置
  THEME: 'theme',
  SIDEBAR_COLLAPSED: 'sidebar_collapsed',
  USER_PREFERENCES: 'user_preferences',
  LAST_VISITED_PAGE: 'last_visited_page',
  
  // 其他可能的缓存
  SEARCH_HISTORY: 'search_history',
  FILTER_SETTINGS: 'filter_settings',
  TABLE_STATE: 'table_state',
  FORM_DATA: 'form_data'
}

// 标签页隔离的token管理系统
// 每个标签页都有独立的token，避免多标签页登录冲突

// 生成唯一的标签页ID
function generateTabId(): string {
  const timestamp = Date.now()
  const randomStr = Math.random().toString(36).substr(2, 9)
  const tabId = `tab_${timestamp}_${randomStr}`
  
  console.log(`🆔 生成新标签页ID: ${tabId}`)
  return tabId
}

// 获取或生成标签页ID
function getTabId(): string {
  let tabId = sessionStorage.getItem('tab_id')
  
  if (!tabId) {
    // 尝试从localStorage中查找当前活跃的标签页
    const activeTab = findActiveTabFromStorage()
    if (activeTab) {
      tabId = activeTab.tabId
      // 恢复标签页ID到sessionStorage
      sessionStorage.setItem('tab_id', tabId)
      console.log(`🔄 恢复标签页ID: ${tabId}`)
    } else {
      // 如果找不到活跃标签页，生成新的
      tabId = generateTabId()
      sessionStorage.setItem('tab_id', tabId)
      console.log(`🆕 生成新标签页ID: ${tabId}`)
    }
  }
  
  return tabId
}

// 从localStorage中查找活跃的标签页
function findActiveTabFromStorage(): { tabId: string; token: string; lastActivity: number } | null {
  try {
    const tokenKeys = Object.keys(localStorage).filter(key => key.startsWith('tab_token_'))
    const activeTabs: Array<{ tabId: string; token: string; lastActivity: number }> = []
    
    for (const key of tokenKeys) {
      const tabId = key.replace('tab_token_', '')
      const token = localStorage.getItem(key)
      const lastActivityKey = `tab_last_activity_${tabId}`
      const lastActivity = localStorage.getItem(lastActivityKey)
      
      // 过滤掉空值、无效值
      if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
        activeTabs.push({
          tabId,
          token,
          lastActivity: lastActivity ? parseInt(lastActivity) : Date.now()
        })
      }
    }
    
    if (activeTabs.length === 0) {
      return null
    }
    
    // 按最后活动时间排序，返回最活跃的标签页
    activeTabs.sort((a, b) => b.lastActivity - a.lastActivity)
    return activeTabs[0]
  } catch (error) {
    console.error('❌ 查找活跃标签页失败:', error)
    return null
  }
}

// 检查当前标签页是否是新创建的
function isNewTab(): boolean {
  if (typeof window === 'undefined') return false
  
  const tabId = getTabId()
  const tokenKey = `tab_token_${tabId}`
  const token = localStorage.getItem(tokenKey)
  
  // 检查是否有有效的token
  const hasValidToken = token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5
  
  return !hasValidToken
}

// 生成token的key
function getTokenKey(): string {
  const tabId = getTabId()
  return `tab_token_${tabId}`
}

// 生成心跳检测的key
function getHeartbeatKey(): string {
  const tabId = getTabId()
  return `tab_heartbeat_${tabId}`
}

// 生成最后活动时间的key
function getLastActivityKey(): string {
  const tabId = getTabId()
  return `tab_last_activity_${tabId}`
}

/**
 * 设置当前标签页的token
 */
export function setTabToken(token: string): void {
  try {
    if (typeof window === 'undefined') return
    
    if (!token || token.trim() === '') {
      console.warn('⚠️ 尝试设置空token，跳过')
      return
    }
    
    const tabId = getTabId()
    if (!tabId) {
      console.error('❌ 无法获取标签页ID，跳过token设置')
      return
    }
    
    // 设置token
    localStorage.setItem(`tab_token_${tabId}`, token)
    
    // 更新最后活动时间
    localStorage.setItem(`tab_last_activity_${tabId}`, Date.now().toString())
    
    // 启动心跳检测
    startHeartbeat()
    
    // 设置页面关闭检测
    setupPageCloseDetection()
    
    console.log(`✅ Token已设置到标签页 ${tabId}`)
  } catch (error) {
    console.error('❌ 设置Token失败:', error)
  }
}

// 获取当前标签页的token
export function getTabToken(): string | null {
  if (typeof window === 'undefined') return null
  
  const key = getTokenKey()
  const token = localStorage.getItem(key)
  
  // 检查token是否为空值或无效值
  if (!token || token.trim() === '' || token === '无' || token === '无...' || token.length < 5) {
    console.log('❌ Token无效，自动清理')
    clearTabToken()
    return null
  }
  
  // 检查token是否过期
  if (isTokenExpired()) {
    console.log('⏰ Token已过期，自动清理')
    clearTabToken()
    return null
  }
  
  // 更新最后活动时间
  updateLastActivity()
  
  return token
}

// 检查token是否过期（2小时过期）
function isTokenExpired(): boolean {
  const lastActivityKey = getLastActivityKey()
  const lastActivity = localStorage.getItem(lastActivityKey)
  
  if (!lastActivity) return true
  
  const lastTime = parseInt(lastActivity)
  const currentTime = Date.now()
  const expirationTime = 2 * 60 * 60 * 1000 // 2小时
  
  const isExpired = (currentTime - lastTime) > expirationTime
  
  if (isExpired) {
    console.log(`⏰ Token已过期，最后活动时间: ${new Date(lastTime).toLocaleString()}`)
  }
  
  return isExpired
}

// 更新最后活动时间
function updateLastActivity(): void {
  const lastActivityKey = getLastActivityKey()
  const currentTime = Date.now()
  localStorage.setItem(lastActivityKey, currentTime.toString())
  
  // 记录活动时间更新
  console.log(`🔄 活动时间已更新: ${new Date(currentTime).toLocaleString()}`)
}

// 清除当前标签页的token
export function clearTabToken(): void {
  if (typeof window === 'undefined') return
  
  const key = getTokenKey()
  const heartbeatKey = getHeartbeatKey()
  const lastActivityKey = getLastActivityKey()
  
  localStorage.removeItem(key)
  localStorage.removeItem(heartbeatKey)
  localStorage.removeItem(lastActivityKey)
  
  // 停止心跳检测
  stopHeartbeat()
  
  // 清理sessionStorage中的标签页ID
  sessionStorage.removeItem('tab_id')
  
  console.log(`🧹 Token已从标签页清除: ${key}`)
}

// 检查当前标签页是否有有效的token
export function hasValidTabToken(): boolean {
  try {
    // 1. 检查当前标签页token
    const currentToken = getTabToken()
    if (currentToken && currentToken.trim() !== '' && currentToken !== '无' && currentToken !== '无...' && currentToken.length >= 5) {
      return true
    }
    
    // 2. 如果没有当前token，尝试恢复其他有效token
    const allTokens = getAllActiveTokens()
    if (allTokens.length > 0) {
      // 自动恢复最活跃的token
      const mostActive = allTokens[0]
      console.log(`🔄 当前标签页无有效token，自动恢复标签页 ${mostActive.tabId} 的token`)
      setTabToken(mostActive.token)
      return true
    }
    
    return false
  } catch (error) {
    console.error('❌ 检查token有效性失败:', error)
    return false
  }
}

// 心跳检测相关
let heartbeatInterval: NodeJS.Timeout | null = null
let heartbeatTimeout: NodeJS.Timeout | null = null
let isHeartbeatRunning = false

// 启动心跳检测
function startHeartbeat(): void {
  if (isHeartbeatRunning) return
  
  isHeartbeatRunning = true
  
  // 每30秒发送一次心跳
  heartbeatInterval = setInterval(() => {
    const token = getTabToken()
    if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
      // 发送心跳请求到后端
      sendHeartbeat(token)
    } else {
      // 如果没有有效token，停止心跳
      stopHeartbeat()
    }
  }, 30000) // 30秒
  
  console.log('💓 心跳检测已启动')
}

// 停止心跳检测
function stopHeartbeat(): void {
  if (heartbeatInterval) {
    clearInterval(heartbeatInterval)
    heartbeatInterval = null
  }
  
  if (heartbeatTimeout) {
    clearTimeout(heartbeatTimeout)
    heartbeatTimeout = null
  }
  
  isHeartbeatRunning = false
  console.log('💓 心跳检测已停止')
}

// 发送心跳请求
function sendHeartbeat(token: string): void {
  // 验证token有效性
  if (!token || token.trim() === '' || token === '无' || token === '无...' || token.length < 5) {
    console.log('❌ 心跳检测跳过：token无效')
    return
  }
  
  // 使用 sendBeacon 发送心跳，确保在页面关闭时也能发送
  const url = '/api/auth/heartbeat'
  const data = new FormData()
  data.append('token', token)
  
  if (navigator.sendBeacon) {
    const success = navigator.sendBeacon(url, data)
    console.log('💓 心跳检测发送:', success ? '成功' : '失败')
  } else {
    // 降级方案：使用 fetch
    fetch(url, {
      method: 'POST',
      body: data,
      keepalive: true
    }).then(response => {
      console.log('💓 心跳检测发送成功:', response.status)
    }).catch(error => {
      console.error('💓 心跳检测发送失败:', error)
    })
  }
}

// 页面关闭检测
let cleanupFunction: (() => void) | null = null

function setupPageCloseDetection(): void {
  if (typeof window === 'undefined') return
  
  // 如果已经有清理函数，先清理
  if (cleanupFunction) {
    cleanupFunction()
  }
  
  // 使用 pagehide 事件（比 beforeunload 更可靠）
  const handlePageHide = (event: PageTransitionEvent) => {
    if (event.persisted) {
      // 页面被缓存，不清理token
      return
    }
    
    console.log('📱 页面即将关闭，清理token')
    cleanupOnPageClose()
  }
  
  // 使用 visibilitychange 事件检测标签页切换
  const handleVisibilityChange = () => {
    if (document.visibilityState === 'hidden') {
      // 标签页被隐藏，可能是切换或关闭
      console.log('👁️ 标签页被隐藏')
    } else if (document.visibilityState === 'visible') {
      // 标签页重新可见，更新活动时间
      const token = getTabToken()
      if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
        updateLastActivity()
      }
    }
  }
  
  // 使用 beforeunload 作为备用方案
  const handleBeforeUnload = () => {
    console.log('🚪 页面即将卸载，清理token')
    cleanupOnPageClose()
  }
  
  // 添加事件监听器
  window.addEventListener('pagehide', handlePageHide)
  document.addEventListener('visibilitychange', handleVisibilityChange)
  window.addEventListener('beforeunload', handleBeforeUnload)
  
  // 保存清理函数
  cleanupFunction = () => {
    window.removeEventListener('pagehide', handlePageHide)
    document.removeEventListener('visibilitychange', handleVisibilityChange)
    window.removeEventListener('beforeunload', handleBeforeUnload)
  }
}

// 页面关闭时的清理操作
function cleanupOnPageClose(): void {
  const token = getTabToken()
  if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
    // 发送清理请求到后端
    sendCleanupRequest(token)
    
    // 清理本地存储
    clearTabToken()
  } else {
    // 即使没有有效token，也要清理本地存储
    clearTabToken()
  }
}

// 发送清理请求
function sendCleanupRequest(token: string): void {
  // 验证token有效性
  if (!token || token.trim() === '' || token === '无' || token === '无...' || token.length < 5) {
    console.log('❌ 清理请求跳过：token无效')
    return
  }
  
  const url = '/api/auth/cleanup'
  const data = new FormData()
  data.append('token', token)
  
  // 使用 sendBeacon 确保请求能发送
  if (navigator.sendBeacon) {
    const success = navigator.sendBeacon(url, data)
    console.log('🧹 清理请求发送:', success ? '成功' : '失败')
  } else {
    // 降级方案
    fetch(url, {
      method: 'POST',
      body: data,
      keepalive: true
    }).then(response => {
      console.log('🧹 清理请求发送成功:', response.status)
    }).catch(error => {
      console.error('🧹 清理请求发送失败:', error)
    })
  }
}

// 清理所有过期的token（用于定期清理）
export function cleanupExpiredTokens(): void {
  if (typeof window === 'undefined') return
  
  const keys = Object.keys(localStorage)
  const tokenKeys = keys.filter(key => key.startsWith('tab_token_'))
  
  tokenKeys.forEach(key => {
    const token = localStorage.getItem(key)
    // 过滤掉空值、无效值
    if (!token || token.trim() === '' || token === '无' || token === '无...' || token.length < 5) {
      console.log(`🧹 清理无效token: ${key}`)
      localStorage.removeItem(key)
      
      // 清理相关的其他key
      const tabId = key.replace('tab_token_', '')
      localStorage.removeItem(`tab_heartbeat_${tabId}`)
      localStorage.removeItem(`tab_last_activity_${tabId}`)
      
      // 如果清理的是当前标签页的token，也要清理sessionStorage中的标签页ID
      const currentTabId = getTabId()
      if (tabId === currentTabId) {
        sessionStorage.removeItem('tab_id')
      }
      return
    }
    
    // 检查token是否过期
    if (isTokenExpired()) {
      console.log(`🧹 清理过期token: ${key}`)
      localStorage.removeItem(key)
      
      // 清理相关的其他key
      const tabId = key.replace('tab_token_', '')
      localStorage.removeItem(`tab_heartbeat_${tabId}`)
      localStorage.removeItem(`tab_last_activity_${tabId}`)
      
      // 如果清理的是当前标签页的token，也要清理sessionStorage中的标签页ID
      const currentTabId = getTabId()
      if (tabId === currentTabId) {
        sessionStorage.removeItem('tab_id')
      }
    }
  })
}

/**
 * 获取所有标签页的token信息
 */
export function getAllActiveTokens(): Array<{ tabId: string; token: string; isCurrent: boolean; lastActivity: number | null }> {
  try {
    const currentTabId = getTabId()
    const tokens: Array<{ tabId: string; token: string; isCurrent: boolean; lastActivity: number | null }> = []
    
    // 遍历localStorage找到所有标签页token
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith('tab_token_')) {
        const tabId = key.replace('tab_token_', '')
        const token = localStorage.getItem(key)
        const lastActivityKey = `tab_last_activity_${tabId}`
        const lastActivity = localStorage.getItem(lastActivityKey)
        
        // 过滤掉空值、无效值
        if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
          tokens.push({
            tabId,
            token,
            isCurrent: tabId === currentTabId,
            lastActivity: lastActivity ? parseInt(lastActivity) : null
          })
        }
      }
    }
    
    // 按最后活动时间排序，最活跃的排在前面
    tokens.sort((a, b) => {
      const aTime = a.lastActivity || 0
      const bTime = b.lastActivity || 0
      return bTime - aTime
    })
    
    return tokens
  } catch (error) {
    console.error('❌ 获取标签页Token信息失败:', error)
    return []
  }
}

// 清理用户相关的所有缓存
export function clearUserCache(): void {
  if (typeof window === 'undefined') return
  
  // 清理当前标签页的token
  clearTabToken()
  
  // 清理其他用户相关的缓存
  const keys = Object.keys(localStorage)
  const userKeys = keys.filter(key => 
    key.startsWith('user_') || 
    key.startsWith('auth_') ||
    key === 'admin_token' // 兼容旧的token
  )
  
  userKeys.forEach(key => {
    const value = localStorage.getItem(key)
    localStorage.removeItem(key)
    if (value) {
      console.log(`🧹 清理用户缓存: ${key} - ${value.substring(0, 30)}...`)
    } else {
      console.log(`🧹 清理空用户缓存: ${key}`)
    }
  })
  
  // 清理sessionStorage中的用户相关数据
  const sessionKeys = Object.keys(sessionStorage)
  const sessionUserKeys = sessionKeys.filter(key => 
    key.startsWith('user_') || 
    key.startsWith('auth_')
  )
  
  sessionUserKeys.forEach(key => {
    const value = sessionStorage.getItem(key)
    sessionStorage.removeItem(key)
    if (value) {
      console.log(`🧹 清理session缓存: ${key} - ${value.substring(0, 30)}...`)
    } else {
      console.log(`🧹 清理空session缓存: ${key}`)
    }
  })
  
  // 清理sessionStorage中的标签页ID
  sessionStorage.removeItem('tab_id')
}

// 初始化时启动定期清理
if (typeof window !== 'undefined') {
  // 每30分钟清理一次过期的token（减少频繁清理）
  setInterval(cleanupExpiredTokens, 30 * 60 * 1000)
  
  // 页面加载时清理一次
  setTimeout(cleanupExpiredTokens, 1000)
  
  // 页面加载完成后，尝试恢复token状态
  setTimeout(() => {
    const token = getTabToken()
    if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
      console.log('🔄 页面加载完成，恢复token状态')
      // 持久化当前token
      persistTabToken()
      // 重新启动心跳检测
      startHeartbeat()
      // 重新设置页面关闭检测
      setupPageCloseDetection()
    } else {
      console.log('🔄 页面加载完成，无有效token')
    }
  }, 100)
  
  // 页面关闭前持久化token
  window.addEventListener('beforeunload', () => {
    const token = getTabToken()
    if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
      persistTabToken()
    }
  })
}

/**
 * 获取所有标签页的token信息
 */
export function getAllTabTokens(): Array<{ tabId: string; token: string | null; isCurrent: boolean; lastActivity: number | null }> {
  try {
    const currentTabId = getTabId()
    const tokens: Array<{ tabId: string; token: string | null; isCurrent: boolean; lastActivity: number | null }> = []
    
    // 遍历localStorage找到所有标签页token
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith('tab_token_')) {
        const tabId = key.replace('tab_token_', '')
        const token = localStorage.getItem(key)
        const lastActivityKey = `tab_last_activity_${tabId}`
        const lastActivity = localStorage.getItem(lastActivityKey)
        
        // 过滤掉空值、无效值
        if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
          tokens.push({
            tabId,
            token,
            isCurrent: tabId === currentTabId,
            lastActivity: lastActivity ? parseInt(lastActivity) : null
          })
        }
      }
    }
    
    return tokens
  } catch (error) {
    console.error('❌ 获取标签页Token信息失败:', error)
    return []
  }
}

/**
 * 清理所有标签页的token（管理员功能）
 */
export function clearAllTabTokens(): void {
  try {
    const currentTabId = getTabId()
    
    // 清理所有标签页token及其相关数据
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith('tab_token_')) {
        const tabId = key.replace('tab_token_', '')
        const token = localStorage.getItem(key)
        
        // 记录清理的token信息
        if (token) {
          console.log(`🧹 清理标签页token: ${tabId} - ${token.substring(0, 20)}...`)
        } else {
          console.log(`🧹 清理空标签页token: ${tabId}`)
        }
        
        localStorage.removeItem(key)
        
        // 清理相关的其他key
        localStorage.removeItem(`tab_heartbeat_${tabId}`)
        localStorage.removeItem(`tab_last_activity_${tabId}`)
      }
    }
    
    // 清理全局token
    localStorage.removeItem(CACHE_KEYS.AUTH_TOKEN)
    
    // 停止当前标签页的心跳检测
    stopHeartbeat()
    
    console.log(`✅ 所有标签页Token已清理，当前标签页: ${currentTabId}`)
  } catch (error) {
    console.error('❌ 清理所有标签页Token失败:', error)
  }
}

/**
 * 清理特定类型的缓存
 */
export function clearCacheByType(type: 'auth' | 'preferences' | 'all'): void {
  try {
    switch (type) {
      case 'auth':
        // 只清理认证相关缓存
        const oldToken = localStorage.getItem(CACHE_KEYS.AUTH_TOKEN)
        localStorage.removeItem(CACHE_KEYS.AUTH_TOKEN)
        if (oldToken) {
          console.log(`🧹 清理认证缓存: ${CACHE_KEYS.AUTH_TOKEN} - ${oldToken.substring(0, 30)}...`)
        } else {
          console.log(`🧹 清理空认证缓存: ${CACHE_KEYS.AUTH_TOKEN}`)
        }
        // 清理当前标签页的token
        clearTabToken()
        // 清理sessionStorage中的标签页ID
        sessionStorage.removeItem('tab_id')
        break
        
      case 'preferences':
        // 清理用户偏好设置
        const theme = localStorage.getItem(CACHE_KEYS.THEME)
        const sidebarCollapsed = localStorage.getItem(CACHE_KEYS.SIDEBAR_COLLAPSED)
        const userPreferences = localStorage.getItem(CACHE_KEYS.USER_PREFERENCES)
        const lastVisitedPage = localStorage.getItem(CACHE_KEYS.LAST_VISITED_PAGE)
        
        localStorage.removeItem(CACHE_KEYS.THEME)
        localStorage.removeItem(CACHE_KEYS.SIDEBAR_COLLAPSED)
        localStorage.removeItem(CACHE_KEYS.USER_PREFERENCES)
        localStorage.removeItem(CACHE_KEYS.LAST_VISITED_PAGE)
        
        console.log(`🧹 清理偏好设置缓存: theme=${theme}, sidebar=${sidebarCollapsed}, preferences=${userPreferences}, lastPage=${lastVisitedPage}`)
        break
        
      case 'all':
        // 清理所有缓存
        clearUserCache()
        break
    }
    
    console.log(`✅ ${type} 类型缓存清理完成`)
  } catch (error) {
    console.error(`❌ ${type} 类型缓存清理失败:`, error)
  }
}

/**
 * 获取缓存使用情况
 */
export function getCacheInfo(): { localStorage: number; sessionStorage: number; itemCount: { localStorage: number; sessionStorage: number } } {
  try {
    // 过滤掉空值和无效值
    const localStorageItems = Object.keys(localStorage)
      .map(key => localStorage.getItem(key))
      .filter(value => value && value.trim() !== '' && value !== '无' && value !== '无...' && value.length >= 5)
    
    const sessionStorageItems = Object.keys(sessionStorage)
      .map(key => sessionStorage.getItem(key))
      .filter(value => value && value.trim() !== '' && value !== '无' && value !== '无...' && value.length >= 5)
    
    const localStorageSize = new Blob(localStorageItems).size
    const sessionStorageSize = new Blob(sessionStorageItems).size
    
    return {
      localStorage: localStorageSize,
      sessionStorage: sessionStorageSize,
      itemCount: {
        localStorage: localStorageItems.length,
        sessionStorage: sessionStorageItems.length
      }
    }
  } catch (error) {
    console.error('获取缓存信息失败:', error)
    return { localStorage: 0, sessionStorage: 0, itemCount: { localStorage: 0, sessionStorage: 0 } }
  }
}

/**
 * 检查是否有用户相关缓存
 */
export function hasUserCache(): boolean {
  return Object.values(CACHE_KEYS).some(key => {
    const value = localStorage.getItem(key)
    return value && value.trim() !== '' && value !== '无' && value !== '无...' && value.length >= 5
  })
}

/**
 * 持久化当前标签页的token（用于页面刷新后恢复）
 */
export function persistTabToken(): void {
  try {
    const token = getTabToken()
    if (token && token.trim() !== '' && token !== '无' && token !== '无...' && token.length >= 5) {
      // 将当前标签页的token标记为持久化
      localStorage.setItem('persistent_token', token)
      localStorage.setItem('persistent_tab_id', getTabId())
      localStorage.setItem('persistent_timestamp', Date.now().toString())
      console.log('💾 持久化token成功')
    }
  } catch (error) {
    console.error('❌ 持久化token失败:', error)
  }
}

/**
 * 恢复持久化的token
 */
export function restorePersistentToken(): string | null {
  try {
    const persistentToken = localStorage.getItem('persistent_token')
    const persistentTabId = localStorage.getItem('persistent_tab_id')
    const persistentTimestamp = localStorage.getItem('persistent_timestamp')
    
    if (persistentToken && persistentTabId && persistentTimestamp) {
      const timestamp = parseInt(persistentTimestamp)
      const now = Date.now()
      
      // 检查token是否在24小时内（86400000毫秒）
      if (now - timestamp < 24 * 60 * 60 * 1000) {
        // 恢复持久化的token
        setTabToken(persistentToken)
        sessionStorage.setItem('tab_id', persistentTabId)
        console.log('🔄 恢复持久化token成功')
        return persistentToken
      } else {
        // token过期，清理持久化数据
        console.log('⏰ 持久化token已过期，清理数据')
        clearPersistentToken()
      }
    }
    
    return null
  } catch (error) {
    console.error('❌ 恢复持久化token失败:', error)
    return null
  }
}

/**
 * 清理持久化的token
 */
export function clearPersistentToken(): void {
  try {
    localStorage.removeItem('persistent_token')
    localStorage.removeItem('persistent_tab_id')
    localStorage.removeItem('persistent_timestamp')
    console.log('🧹 清理持久化token成功')
  } catch (error) {
    console.error('❌ 清理持久化token失败:', error)
  }
}

/**
 * 增强的token有效性检查（包含持久化token恢复）
 */
export function hasValidTabTokenEnhanced(): boolean {
  try {
    // 1. 检查当前标签页token
    if (hasValidTabToken()) {
      return true
    }
    
    // 2. 尝试恢复持久化token
    const persistentToken = restorePersistentToken()
    if (persistentToken) {
      return hasValidTabToken()
    }
    
    // 3. 尝试恢复其他标签页的token
    const allTokens = getAllActiveTokens()
    if (allTokens.length > 0) {
      const mostActive = allTokens[0]
      setTabToken(mostActive.token)
      return hasValidTabToken()
    }
    
    return false
  } catch (error) {
    console.error('❌ 增强token有效性检查失败:', error)
    return false
  }
}
